home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / asmutil / uasm.zip / 51SYM.C next >
C/C++ Source or Header  |  1986-04-07  |  22KB  |  606 lines
  1. /*
  2.         Custom Computer Consultants
  3.         Universal Cross Assembler
  4.         8051 Symbols
  5.         5 April 1986
  6. */
  7.  
  8. #include <stdio.h>
  9. #include <uasm.h>
  10.  
  11. char   *version = {"8051 Assembler -- V3.2  4/5/86\n"} ;
  12.  
  13. #define BSEG    0       /*      Register Segment        */
  14. #define CSEG    1       /*      Code Segment            */
  15. #define DSEG    2       /*      Data Segment            */
  16. #define XSEG    3       /*      External Data Segment   */
  17. #define ASCII   4       /*      String                  */
  18. #define PAGE    5       /*      Page Eject              */
  19. #define RADIX   6       /*      Define Radix            */
  20. #define BIT     7       /*      Bit Address             */
  21. #define DB      8       /*      Define Byte             */
  22. #define DS      9       /*      Define Storage          */
  23. #define DW      10      /*      Define Word             */
  24. #define EQU     11      /*      Equate                  */
  25. #define ORG     12      /*      Origin                  */
  26.  
  27. extern int     pass1 ;
  28. extern int     lbl ;
  29. extern int     i, j, k ;
  30. extern int     lnspp ;
  31. extern int     cc ;
  32. extern int     ilc ;
  33. extern int     active ;
  34. extern int     instl ;
  35. extern int     parval ;
  36. extern int     radix ;
  37. extern int     cput ;
  38. extern int     syte, sytx ;
  39.  
  40. extern unsigned        unpar ;
  41. extern unsigned        ha, he, hsp ;
  42.  
  43. extern unsigned  char    ch ;
  44. extern unsigned  char    sym ;
  45.  
  46. extern char    *iptr ;  
  47. extern char    segtype[] ;
  48.  
  49. extern unsigned  char    ib[] ;
  50. extern unsigned  char    pv[] ;
  51. extern unsigned  char    px[] ;
  52.  
  53. extern           int     pj[] ;
  54. extern           int     il[] ;
  55. extern char    *pc[], *pseudo[] ;
  56.  
  57. extern int     (*pp[])() ;
  58. extern int     (*ppo[])() ;
  59.  
  60. extern char    ibuf[] ;
  61.  
  62. extern struct  symbol  symtab[] ;
  63.  
  64. #define SYMTYPE  (symtab[sytx].flags&(NSEG-1))
  65.  
  66. code_seg() { return CSEG ; }
  67.  
  68. not_cseg(seg)
  69. int    seg ;
  70. {
  71.        if( seg == BSEG || seg == DSEG ) return TRUE ;
  72.        else return FALSE ;
  73. }
  74.  
  75. set_il()
  76. {
  77.        il[BSEG] =     0 ;
  78.        il[CSEG] =     0 ;
  79.        il[DSEG] =    32 ;
  80.        il[XSEG] = 16384 ;
  81. }
  82.  
  83. set_type()
  84. {
  85.        segtype[BSEG] = '^'  ;
  86.        segtype[CSEG] = '\'' ;
  87.        segtype[DSEG] = '\"' ;
  88.        segtype[XSEG] = '+'  ;
  89. }
  90.  
  91.  
  92. gen(len)
  93. int     len ;
  94. {
  95.         ib[2] = parval & 0xFF ;
  96.         ib[1] = len == 3 ? parval >> 8 : ib[2] ;
  97.         instl = len ;
  98.         ib[0] = pv[k] ;
  99.         return TRUE ;
  100. }               
  101.  
  102. nopr()  { return gen(1) ; }
  103.  
  104. accm()  { if( nomatch("A") )            return FALSE ;
  105.           return gen(1) ; }
  106.  
  107. abac()  { if( nomatch("AB") )           return FALSE ;
  108.           return gen(1) ; }
  109.  
  110. cflg()  { if( nomatch("C") )            return FALSE ;
  111.           return gen(1) ; }
  112.  
  113. dptr()  { if( nomatch("DPTR") )         return FALSE ;
  114.           return gen(1) ; }
  115.  
  116. bita()  { parval = eval() ;
  117.           return gen(2) ;  }
  118.  
  119. dadr()  { parval = eval() ;
  120.           return gen(2) ;  }
  121.  
  122. adrl()  { parval = eval() ;
  123.           return gen(3) ;  }
  124.  
  125. adrs()  { parval = eval() ;
  126.           gen(2) ;
  127.           ib[0] |= (( parval >> 3 ) & 0xE0 ) ;
  128.           return TRUE  ; }
  129.  
  130. adrx()  { unpar = parval = eval() ;
  131.           
  132.           if ( unpar < 2048 )
  133.                 { gen(2) ; ib[0] |= (( unpar >> 3 ) & 0xE0 ) ; }
  134.           else  { gen(3) ; ++ib[0] ; }
  135.  
  136.           return TRUE  ; }
  137.  
  138. rela()  { crela(2) ;
  139.           return gen(2) ; }
  140.  
  141. crela(n)
  142. int     n ;
  143. {
  144.         parval = eval() - ( ilc + n ) ;
  145.         if( parval > 127 || parval < -128 ) push('R') ;
  146. }
  147.  
  148.  
  149. acir()  { if( nomatch("A,") )           return FALSE ;
  150.           return indr() ; }
  151.  
  152. indr()  { if( nomatch("@R") )           return FALSE ;
  153.           if( ch < '0' ||
  154.               ch > '1'   )              return FALSE ;
  155.           gen(1) ;
  156.           ib[0] |= ( 0x01 & ( ch - '0' ) ) ;
  157.           getch() ;
  158.           return TRUE  ; }
  159.  
  160. irim()  { if( !indr() )                 return FALSE ;
  161.           if( nomatch(",#") )           return FALSE ;
  162.           parval = eval() ;
  163.           ib[1] = parval & 0xFF ;
  164.           ++instl ;
  165.           return TRUE ; }
  166.  
  167. irac()  { if( !indr() )                 return FALSE ;
  168.           if( nomatch(",A") )           return FALSE ;
  169.           return TRUE ; }
  170.  
  171. irdd()  { if( !indr() )                 return FALSE ;
  172.           if( notcomma() )              return FALSE ;
  173.           if( !alphanum(ch) )           return FALSE ;
  174.           parval = eval() ;
  175.           ib[1] = parval & 0xFF ;
  176.           ++instl ;
  177.           return TRUE ; }
  178.  
  179. acrg()  { if( nomatch("A,") )           return FALSE ;
  180.           return regr() ; }
  181.  
  182. regr()  { if( nomatch("R") )            return FALSE ;
  183.           if( ch < '0' ||
  184.               ch > '7'    )             return FALSE ;
  185.           gen(1) ;
  186.           ib[0] |= ( 0x07 & ( ch - '0' ) ) ;
  187.           getch() ;
  188.           return TRUE ; }
  189.  
  190. rgim()  { if( !regr() )                 return FALSE ;
  191.           if( nomatch(",#") )           return FALSE ;
  192.           parval = eval() ;
  193.           ib[1] = parval & 0xFF ;
  194.           ++instl ;
  195.           return TRUE ; }
  196.  
  197. rgac()  { if( !regr() )                 return FALSE ;
  198.           if( nomatch(",A") )           return FALSE ;
  199.           return TRUE ; }
  200.  
  201. rgdd()  { if( !regr() )                 return FALSE ;
  202.           if( notcomma() )              return FALSE ;
  203.           if( !alphanum(ch) )           return FALSE ;
  204.           parval = eval() ;
  205.           ib[1] = parval & 0xFF ;
  206.           ++instl ;
  207.           return TRUE ; }
  208.  
  209. apdp()  { if( nomatch("@A+DPTR") )      return FALSE ;
  210.           return gen(1) ; }
  211.  
  212.  
  213. dpim()  { if( nomatch("DPTR,#") )       return FALSE ;
  214.           parval = eval() ;
  215.           return gen(3) ; }
  216.  
  217. acim()  { if( nomatch("A,#") )          return FALSE ;
  218.           parval = eval() ;
  219.           return gen(2) ; }
  220.  
  221. acdd()  { if( nomatch("A,") )           return FALSE ;
  222.           if( !alphanum(ch) )           return FALSE ;
  223.           return dadr() ; }
  224.  
  225. cfcb()  { if( nomatch("C,/") )          return FALSE ;
  226.           if( !alphanum(ch) )           return FALSE ;
  227.           return bita() ; }
  228.  
  229. cfba()  { if( nomatch("C,") )           return FALSE ;
  230.           if( !alphanum(ch) )           return FALSE ;
  231.           return bita() ; }
  232.  
  233. idac()  { if( nomatch("@DPTR,A") )      return FALSE ;
  234.           return gen(1) ; }
  235.  
  236. acid()  { if( nomatch("A,@DPTR") )      return FALSE ;
  237.           return gen(1) ; }
  238.  
  239. acap()  { if( nomatch("A,@A+PC") )      return FALSE ;
  240.           return gen(1) ; }
  241.  
  242. acad()  { if( nomatch("A,@A+DPTR") )    return FALSE ;
  243.           return gen(1) ; }
  244.  
  245. ddim()  { if( !alphanum(ch) )           return FALSE ;
  246.           if( !dadr() )                 return FALSE ;
  247.           if( nomatch(",#") )           return FALSE ;
  248.           parval = eval() ;
  249.           ib[2] = parval & 0xFF ;
  250.           ++instl ;
  251.           return TRUE ; }
  252.  
  253. ddir()  { if( !alphanum(ch) )           return FALSE ;
  254.           parval = eval() ;
  255.           if( notcomma() )              return FALSE ;
  256.           if ( !indr() )                return FALSE ;
  257.           ib[1] = parval & 0xFF ;
  258.           instl = 2 ;
  259.           return TRUE ; }
  260.  
  261. ddrg()  { if( !alphanum(ch) )           return FALSE ;
  262.           parval = eval() ;
  263.           if( notcomma() )              return FALSE ;
  264.           if( !regr() )                 return FALSE ;
  265.           ib[1] = parval & 0xFF ;
  266.           instl = 2 ;
  267.           return TRUE ; }
  268.  
  269. ddac()  { if( !alphanum(ch) )           return FALSE ;
  270.           parval = eval() ;
  271.           if ( nomatch(",A") )          return FALSE ;
  272.           return gen(2) ; }
  273.  
  274. dddd()  { if( !alphanum(ch) )           return FALSE ;
  275.           parval = eval() ;
  276.           if ( notcomma() )             return FALSE ;
  277.           ib[1] = parval & 0xFF ;
  278.           if( !alphanum(ch) )           return FALSE ;
  279.           parval = eval() ;
  280.           ib[2] = parval & 0xFF ;
  281.           ib[0] = pv[k] ;
  282.           instl = 3 ;                   return TRUE ; }
  283.  
  284. barl()  { bita() ;
  285.           if( notcomma() )              return FALSE ;
  286.           crela(3) ;
  287.           ib[2] = parv